//
//  GM_NsController.swift
//  SWIFT_LEARN
//
//  Created by youxin on 2018/1/16.
//  Copyright © 2018年 YST. All rights reserved.
//

import UIKit

class GM_NsController: UIViewController {

    var age : Int? = nil
    var name : Optional<String> = nil // 可选类型中自能放一个字符串
    
    override func viewDidLoad() {
        super.viewDidLoad()

        // Do any additional setup after loading the view.
        age = 99
        name = "zhangsan"
        
//        以上拿出来的值是可选类型的Optional("wj") Optional(18)，往往我们想要的只是可选型中的数据，外面的Optional是不需要的。这时就需要用到强制解包，把里面的数据取出来；
//        强制解包的格式 ： 可选类型 + ！
        print(age)
        print(name)
//        注意的是强制解包是非常危险的，往往在解包的时候，如果可选型为nil的时候，会导致系统崩溃，所以在解包的时候需要注意。
//        所以建议在解包的时候，需要判断下可选型是否为nil
        if name != nil {
            print(name!)
        }
        if age != nil {
            print(age!)
        }
        
        
        
        self.test1()
        self.nsarr()
        self.dic()
        self.nsseet()
        self.funcF()
    }
    
    func funcF(){
        
        func sum(_ number1: Int, number2: Int) ->Int {
            return number1 + number2
        }
       let resurlt = sum(20, number2: 30)
        print(resurlt)
        
       // 在有的情况下，我们需要给参数一个默认值，比方说是在选择饮料的时候，如果有特殊要求就给所要求的饮料，如果没有特殊要求就返给默认的饮料就可以了。
        //默认参数
        func makeACupOfCoffee(coffeeName: String) -> String {
            return "制作了一杯\(coffeeName)咖啡"
        }
      let coffee =  makeACupOfCoffee(coffeeName: "拿铁")
        
        //给参数一个默认值，然后调用的时候不传参，打印的值就是制作了一杯雀巢咖啡。
        func makeACupCoffee1(_ coffeeName: String = "雀巢") -> String {
            return "制作了一杯\(coffeeName)咖啡"
        }
       let coffee1 =  makeACupCoffee1("拿铁666")
         let coffee2 =  makeACupCoffee1()
      print(coffee,coffee1,coffee2)
    
        
        func sumAction(num1: Int...) -> Int {
            var result = 0
            for n in num1 {
                result += n
            }
            return result
        }
    let sumNumber = sumAction(num1: 19,20,44)
    
        print(sumNumber)
        
        
        // 定义了两个参数，是可变的。
        var m = 30
        var n = 20
        func swapNmuber(m : inout Int, n : inout Int) {
            let temp = m
            m = n
            n = temp
        }
        swapNmuber(m: &m, n: &n)
        // 以上就把m和n进行值的交换了。
      
        
        func test() {
            func demo() {
                print("demo")
            }
            print("test")
            demo() //调用demo
        }
        test()// 调用test  // 结果 test demo
        
    }
    
    
    
    //元组
    func nsseet(){
        //这样的好处就是不用想数组那样用中括号然后再取下标，元组就直接的用点语法的模式直接取下标拿到对应的值。
        let info = ("name", 18, 1.88)
        // 取出元组中的各元素
        info.0
        info.1
        info.2
        
    //    有的时候，我们希望把元组中的每个元素都对应一个别名，这样有利于编码，元组提供了这种便利，这是最常见的写法
        let info1 = (name : "wj", age : 18, height : 1.88)
        info1.name
        info1.age
        info1.height
        
        let (name, age, height) = ("wj", 18, 1.88)
        name
        age
        height
        
    }
    
    func dic(){
       //注意的是使用的是中括号，不是大括号，系统会自动判断是放置的一个个元素还是一对对的键值对。 -> 类型是[String : String]
        let dict = ["name" : "wj", "age" : "12", "heigth" : "1.88"]
        let dict1 : Dictionary<String, Any> = ["name" : "wj", "age" : 12, "heigth" : 1.88,"aaa":"bbb"] //Any 任何类型
        let dict2 : [String : Any] = ["name" : "wj", "age" : 12, "heigth" : 1.88]
        //var dictM = Dictionary<String , NSObject>()
        //var dictM = [String : NSObject](); // -> 用于创建对象
        
        var dictM = [String : Any]();  // -> 用于指定类型
  
        dictM["name"] = "wj"
        dictM["age"] = 12
        dictM["height"] = 1.88
        dictM["weight"] = 40
        
        //dictM.removeAll()
        dictM.removeValue(forKey: "weight")
        
        dictM["name"] = "WJ"
        
       let age = dictM["age"]
        /// 3.1遍历字典中所有的key
        for key in dictM.keys {
            print(key)
        }
        
        /// 3.2遍历字典中所有的值
        for value in dictM.values {
            print(value)
        }
        
        /// 3.3遍历所有的键值对
        for (key, value) in dictM {
            print(key)
            print(value)
        }
      // 合并字典并不能用+进行合并，即使是相同类型的数据的字典，只能采用遍历的方式进行添加数据。
        
        for (key , value) in dict1 {
            dictM[key] = value
        }
        
        print(dictM)
        
    }
    
    
    
    //数组
    func nsarr(){
        let array = ["111","222","333"]
        let array1 : Array<String> = ["name", "wj", "haha"]
        let array2 : [String] = ["name", "wj", "haha"]
        let arr :[NSInteger] = [1,2,3,4,5]
      
        print(array,array1,array2,arr)
        
        //var arrayM = Array<String>()
        var arrayM = [String]() // 创建了一个可变数组，使用的较多的方法
        // 在数组的最后添加一个元素
        arrayM.append("we")
        arrayM.append("wee")
        arrayM.append("weee")
        // 在数组的第1个位置插入一个元素
        arrayM.insert("insert", at: 1)
       
   
        
        arrayM[0] = "123" //修改元素的时候需要拿到所要修改元素的下标，然后进行修改。
      
        for  name in arrayM {
            print(name)
        }
        
        for i in 0..<arrayM.count {
            print(arrayM[i])
        }
        
        for name in array[0..<1] {
            print(name)
        }
        
        
        arrayM.remove(at: 0) // 删除弟0个元素
        
        arrayM.removeAll() // 删除全部的元素
        
        // 需要注意的是：数组的合并必须是由相同类型的数组进行合并，不同类型的数组不能由`+`连接进行合并的。
        //let result = array + arrayM
        
        let aa = [1,2,3]
        let bb = [4,5,6]
        let cc = aa + bb
        print(cc)

    }

   //字符串
    func test1(){
        //MARK 基本语法url
//        https://www.jianshu.com/p/563738348597
 //       http://blog.csdn.net/binyao02123202/article/details/52268455
        let m = 30
        let n = 20
        let result : NSInteger
        // 三目运算符方式进行判断
         result = m > n ? m : n
        print(m,result)
        print(m)
       
//        for var i = 0; i < 5;i += 1  {
//            
//           print("%@",i)
//        }
//        
        for j in 0..<10 { // 优化成区间的模式来做
            print(j)
        }
        
        //字典合并
        let dict1 = ["name" : "why", "age" : 18] as [String : Any]
        var dict2 = ["height" : 1.88, "phoneNum" : "+86 110"] as [String : Any]
    
         for (key, value) in dict1 {
                 dict2[key] = value
             }
        print(dict2)
        
//        1.3使用 String 的原因
//        String 是一个结构体，性能更高
//        NSString 是一个 OC 对象，性能略差
//        String 支持直接遍历
//        String 提供了 String 和 NSString之间的无缝转换
        
        let str = "12345678"
        let lenth = str.characters.count
        for c in str.characters {
            print(c)
        }
       print(str,lenth)
        
        let str1 = "111"
        let str2 = "222"
        var str3 = str1 + str2
        print(str3)
        
        let name = "lgp"
        let age = 18
        let height = 1.98
        let infoStr = "my name is \(name), age is \(age), height is \(height)"
        print(infoStr)
        
        let min = 3
        let second = 4
        let timeStr = String(format: "%02d:%02d", arguments: [min, second])
        print(timeStr)
        
     //   let i : Int = 10 --> 可以修改成  let i = 10
        // 这是会报错的
//        let x
//            x = 20
        let x : Int
        x = 20
        
//        guard *判断语句* else {
//            *****
//            break\return\continue...
//        }
//        语句组
        let age1  = 20   // guard 不满足条件走  else
       guard age1 >= 18 else {
            
            print("11111111")
        return;
        }
        print("2222222222")
        
        
        // swift  switch k可进行多个条件判断 oc无
//        switch gender {
//        case 0 , 1 :
//            print("正常人")
//            break
//        default :
//            print("其他")
//            break
//        }
        let a = 3.14
        switch a {
        case 3.14:
            print("π")
        default:
            print("not π")
        }
        
        let m1 = 20
        let n1 = 30
        let operation = "+"
        var result1 = 0
        
        // switch 直接判断字符串
        switch operation {
        case "+" :
            result1 = m1 + n1
        case "-" :
            result1 = m1 - n1
        case "*" :
            result1 = m1 * n1
        case "/" :
            result1 = m1 / n1
        default :
            print("非法操作")
        }
        print(result1)
        
        let age2 = 18
        let height2 = 1.88
      
        str3 = "my name is \(name), age is \(age2), height is \(height2)"
        print(str3)
        
        
        //时间拼接
        let minute = 2
        let second1 = 3
        let time1 = "0\(minute):0\(second)"
      let time = String(format: "%02d:%02d", arguments:[minute, second1])
        print(time,time1)
        
        let urlString = "www.baidu.com"
        /// 将String类型转为NSSstring类型 String as NSString
        let header = (urlString as NSString).substring(to: 3)
        let body = (urlString as NSString).substring(with: NSMakeRange(4, 5))
        let footer = (urlString as NSString).substring(from: 10)
        print("header is \(header), body is \(body), footer is \(footer)")
      
        
        
        
        
    }
    

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }
    

    /*
    // MARK: - Navigation

    // In a storyboard-based application, you will often want to do a little preparation before navigation
    override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
        // Get the new view controller using segue.destinationViewController.
        // Pass the selected object to the new view controller.
    }
    */

}
